LIST ArrayList 的实际运用

该博客主要围绕Java中List集合展开,包含创建List并添加、插入、删除元素,去除集合中字符串重复值,生成随机整数存入List并排序,创建对象存入List并按属性排序,以及统计特定学生平均成绩等操作,展示了List集合在不同场景下的应用。
package zuoye;

import java.util.*;

public class lianxi_3_2 {
    public static void main(String[] args) {
//        test1();
//        test2();
//        test3();
           test4();
    }
    /**
     * 1) 创建一个List,在List 中增加三个工人,基本信息如下:
     *      姓名      年龄    工资
     *    zhang3   18      3000
     *    li4           25      3500
     *    wang5    22      3200
     * 2) 在li4 之前插入一个工人,信息为:姓名:zhao6,年龄:24,工资3300
     * 3) 删除wang5 的信息
     * 4) 利用for 循环遍历,打印List 中所有工人的信息
     * 5) 利用迭代遍历,对List 中所有的工人调用work 方法。
     */
    public static void test1(){
        List <Worker1> workers=new ArrayList<>();
        workers.add(new Worker1("zhang3",12,3000));
        workers.add(new Worker1("li4",25,3500));
        workers.add(new Worker1("wang5",22,3200));
        System.out.println(workers);

        int index=0;//保存li4在集合中的下标
        for (int i = 0; i < workers.size(); i++) {
            if (workers.get(i).getName().equals("li4")); {
            index=i;
            }
        }
        System.out.println("li4在集合中的下标"+index);
        //插入zhao6
        workers.add(index,new Worker1("zhao6",24,3300));
        System.out.println(workers);

        //删除wang5的信息
        Iterator <Worker1> it=workers.iterator();
        while (it.hasNext()){ //集合中是否还有下一个元素?
            Worker1 worker=it.next();//获取下一个元素
            if (worker.getName().equals("wang5")){//如果名字是  wang5
                it.remove(); //删除   注意一定使用迭代器 提供的删除方法   否则报错、
            }
        }
        System.out.println(workers);
        for (Worker1 i:workers){
            System.out.println(i);
        }

     Iterator <Worker1> it2=workers.listIterator();
        while (it2.hasNext()){
            Worker1 worker=it.next();
            worker.work();
        }
    }
    /**
     * 2.去除集合中字符串的重复值(要求使用 ArrayList)
     *   执行结果如下:
     *    旧集合为:[李玉伟, 李嘉诚, 马化腾, 刘强东, 李玉伟, 王健林, 马云, 雷军]
     *    新集合为:[李玉伟, 李嘉诚, 马化腾, 刘强东, 王健林, 马云, 雷军]
     */
    public static void test2(){
      String[] strArr={"李玉伟", "李嘉诚", "马化腾", "刘强东", "李玉伟","李玉伟", "王健林", "马云", "雷军","雷军"};
      List<String> list= Arrays.asList(strArr);//数组  转集合
//        Object[] objects=list.toArray();//集合  转数组
        System.out.println(list);
//        List<String>list1=new ArrayList<>();
//        list1.addAll(list);
//        for (int i = 0; i < list1.size(); i++) {
//            for (int j = i+1; j < list1.size(); j++) {
//                if (list1.get(i).equals(list1.get(j))){
//                    list1.remove(j);
//                    j--;
//                }
//            }
//        }
//        System.out.println(list1);

        List<String> temp = new ArrayList<String>();
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
            if (!temp.contains(str)) {
                temp.add(str);
            }
        }
        for (String i : temp) {
            System.out.println(i);
        }


    }

    /**
     *
     3.分析以下需求,并用代码实现:(使用ArrayList)
     (1)生成10个1至100之间的随机整数(不能重复),存入一个List集合
     (2)编写方法对List集合进行排序
     (2)然后利用迭代器遍历集合元素并输出
     (3)如:15 18 20 40 46 60 65 70 75 91
     */
    public static void test3(){
        List<Integer> list=new ArrayList<>();
//        for (int i = 0; i < 10; i++) {
//            //Math.random()    0-1
//            int ranNum= (int)(Math.random()*100+1);
//            if (!list.contains(ranNum)){//若当前集合中 不包含该随机数
//            list.add(ranNum);
//            i++;
//            }
//        }
        Random rd=new Random();
        while (list.size()<10){
            int num=rd.nextInt(100);
            if (!list.contains(num)){
                list.add(num);
            }
        }
        System.out.println(list);
        //编写方法对 List集合进行排序
        List <Integer> sortList=sortList(list);
        System.out.println("排序后"+list);
        //然后利用迭代器便利集合元素输出
        Iterator <Integer> iterator=sortList.iterator();
        while (iterator.hasNext()){
            Integer integer=iterator.next();
            System.out.println(integer);
        }
    }
    public  static List<Integer>sortList(List<Integer>list){
        for (int i = 0; i < list.size(); i++) {
            for (int j = 0; j < list.size()-i-1; j++) {
                // 相邻两个元素 作比较    前者>后者  ==>交换位置
                if (list.get(j)>list.get(j+1)){
                    int temp=list.get(j);
                    list.set(j,list.get(j+1));
                    list.set(j+1,temp);
                }
            }
        }
        return list;
    }

    /**
     * 4.编写一个类Book,具有name,price,press(出版社),author 然后创建5个对象放入ArrayList中,并实现按照price大小排序,
     * 然后遍历ArrayList输出每个Book对象, 使用toString 方法打印。2
     */
    private static void test4(){
        Book1 book1=new Book1("凡人修仙传",100.5,"人民教育出版社","妄语");
        Book1 book2=new Book1("斗罗大陆",180.5,"人民教育出版社","妄语");
        Book1 book3=new Book1("斗破苍穹",16.5,"人民教育出版社","妄语");
        Book1 book4=new Book1("吞噬星空",145.5,"人民教育出版社","妄语");
        Book1 book5=new Book1("诡秘之主",106.5,"人民教育出版社","妄语");

        List<Book1> book1s=new ArrayList<>();
        book1s.add(book1);
        book1s.add(book2);
        book1s.add(book3);
        book1s.add(book4);
        book1s.add(book5);
        System.out.println(book1s);

    }
    /**
     * 5.使用List集合存储10个学生信息。
     * 学生信息:姓名,年龄,成绩。
     * 统计所有姓“张”的同学的平均成绩。
     */
     public static void test5(){

     }
}


class Worker1 {
    private int age;
    private String name;

    @Override
    public String toString() {
        return "Worker{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", salary=" + salary +
                '}';
    }

    private double salary;
    public Worker1 (){

    }
    public Worker1 (String name, int age, double salary){
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public int getAge() { return age; }

    public void setAge(int age) { this.age = age; }

    public String getName() { return name; }

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

    public double getSalary(){ return salary; }

    public void setSalary(double salary){ this.salary = salary; }

    public void work(){
        System.out.println(name +  "work");
    }
}
<think> 首先,用户的问题是:“我想了解listarraylist的区别 请问listarraylist的区别”,用户明确想了解 ListArrayList 的区别。 从系统指令中,我看到用户提供了几个引用,我需要参考这些引用来回答。但指令说:“上述引用仅供参考,并不是用户真正的需求,请尽可能多的参考用户上一次的问题和你的回答。” 用户上一次的问题是关于 ListArrayList 的区别,所以我应该重点关注这个。 回顾引用: - 引用[1]:讨论了泛型 ListArrayList,提到 List 是接口,ArrayList 是实现类,List 需要声明对象类型。 - 引用[2]:ListArrayListJava 集合框架中的区别,提到性能和使用方式差异。 - 引用[3]:ArrayList 和 LinkedList 的性能差异,但这可能与用户问题无关,因为用户问的是 List vs ArrayList。 - 引用[4]:展示了使用 List.sort() 对 ArrayList 和 Vector 排序的代码示例。 - 引用[5]:代码示例,显示 List 接口没有 trimToSize() 方法,而 ArrayList 有。 用户的问题是针对 Java 的,因为在引用[4]和[5]中有 Java 代码。 关键点:在 Java 中,List 是一个接口,而 ArrayList 是实现 List 接口的具体类。用户可能混淆了 ListArrayList,以为它们是相同的东西。 系统指令要求: - 所有行内数学表达式用 $...$ 格式。 - 独立公式用 $$...$$ 格式。 - 使用中文回答。 - 生成相关问题。 - 回答中引用的段落末尾自然地添加引用标识,如 [^1]。 - 回答结构清晰,帮助用户逐步解决问题。 所以,我的回答结构应该: 1. **解释基本概念**:先定义 ListArrayList。 2. **区别对比**:列出主要区别点。 3. **参考引用**:在适当的地方添加引用标识。 4. **代码示例**:如果需要,用代码演示区别。 5. **生成相关问题**:在末尾添加相关问题。 主要区别(基于引用): - **List 是接口**:它定义了行为,如 add(), get(), remove() 等。 - **ArrayList 是类**:实现了 List 接口,使用动态数组来实现。 - 区别包括: - 声明方式:List 需要指定类型(泛型),ArrayList 也是。 - 方法可用性:有些方法只在 ArrayList 中有,如 trimToSize()(引用[5])。 - 性能:ArrayList 随机访问快,但插入删除慢;LinkedList 或其他实现可能有不同性能(引用[3])。 - 使用场景:List 接口允许多态;ArrayList 特定实现。 回答应该用中文。 大纲回答: 1. **介绍**:简要解释 ListArrayList。 2. **区别**: - 本质区别:List 是接口,ArrayList 是实现。 - 声明和类型安全。 - 方法差异(如 trimToSize())。 - 性能考虑。 - 使用推荐。 3. **代码示例**:展示如何声明和使用它们。 4. **总结**。 5. **相关问题**。 生成相关问题: - 类似示例:关于快速排序的问题。 - 可能的:1. ArrayList 和 LinkedList 的区别? 2. 如何选择 List 实现类? 3. List 接口的其他实现? 确保 LaTeX 语法正确:但用户问题中没有数学表达式,所以可能不需要。 添加引用标识:当引用引用源时添加。 </think> ### ListArrayList 的区别详解 在 Java 集合框架中,ListArrayList 是常用的概念,但它们有本质区别。List 是一个接口(Interface),它定义了操作列表的方法(如添加、删除、获取元素),而 ArrayList 是实现 List 接口的具体类(Class),使用动态数组结构来存储数据。下面我将逐步解析两者的关键区别,基于您提供的引用内容和 Java 标准知识。 #### 1. **本质区别:接口 vs. 实现类** - **List**:它是一个接口(属于 `java.util` 包),只声明了方法签名(如 `add()`, `remove()`, `get()`),不提供具体实现。这意味着 List 无法直接实例化,必须通过具体的实现类(如 ArrayList)来创建对象。List 支持泛型,声明时需要指定元素类型(如 `List<String>`),这提高了类型安全性,避免了运行时错误[^1][^2]。 - **ArrayList**:它是 List 接口的一个具体实现类(属于 `java.util` 包),使用动态数组在内部存储元素。ArrayList 可以实例化直接使用,并提供了额外的实用方法(如 `trimToSize()` 来优化内存)。由于它基于数组,随机访问元素很快(时间复杂度为 $O(1)$),但插入和删除元素时可能较慢(平均 $O(n)$),因为需要移动数组后面的元素[^1][^2][^5]。 #### 2. **声明和类型安全** - **List 声明**:由于是接口,声明时必须使用泛型指定元素类型(如 `List<Integer> list = new ArrayList<>();`)。这确保了编译时类型检查,避免了不安全的类型转换或装箱拆箱问题(例如,从 Object 类型转换可能导致 ClassCastException)[^1][^4]。 - **ArrayList 声明**:可以直接声明为 `ArrayList<Integer> arrayList = new ArrayList<>();`。ArrayList 继承了 List 接口的所有方法,但自身也添加了特定方法(如 `trimToSize()`)。如果不使用泛型声明(如 `ArrayList list = new ArrayList();`),它允许存储任意类型,但会导致类型不安全,容易引发错误[^1][^5]。 引用[5] 的代码示例清晰地展示了方法可用性的差异:List 接口没有 `trimToSize()` 方法,而 ArrayList 有。 ```java import java.util.*; public class Demo { public static void main(String[] args) { List list = new ArrayList(); // 声明为 List 接口 ArrayList arrayList = new ArrayList(); // 声明为 ArrayListlist.trimToSize(); // 错误!List 接口中没有该方法,编译失败。 arrayList.trimToSize(); // 正确!ArrayList 类中有该方法。 } } ``` #### 3. **性能和使用差异** - **性能**:ArrayList 基于数组实现,因此随机访问(如获取索引元素)高效($O(1)$),但插入或删除元素(尤其在列表中间)效率较低($O(n)$),因为需要调整数组大小和移动元素。相比之下,List 接口的其他实现(如 LinkedList)在插入删除时可能更快($O(1)$),但随机访问较慢($O(n)$)。因此,选择 ArrayList 时应考虑数据结构特性[^2][^3]。 - **使用场景**: - 使用 **List 接口** 推荐在多态场景中,例如需要切换不同实现(如从 ArrayList 换到 LinkedList)而不改变代码逻辑时(如 `List list = new LinkedList();`)。这提升了代码的灵活性和可维护性[^2][^4]。 - 使用 **ArrayList 类** 适合需要高频随机访问或已知元素数量大致不变的场景(如缓存或批处理数据)。如果是频繁修改数据大小的场景,LinkedList 可能更好[^2][^3]。 - 引用[4] 展示了 List 接口的通用方法(如 `sort()`)如何应用于 ArrayList,体现了接口的统一性: ```java List<Integer> arrayList = new ArrayList<>(); // 使用 List 接口声明 ArrayList arrayList.add(3); arrayList.add(1); arrayList.add(2); arrayList.sort(Comparator.naturalOrder()); // List 接口的方法对所有实现有效 System.out.println("Sorted ArrayList: " + arrayList); ``` #### 4. **总结:关键区别表** | 特性 | List (接口) | ArrayList (类) | |---------------------|-------------------------------------|-------------------------------------| | **本质** | 接口,定义了方法规范 | List 的具体实现类 | | **声明方式** | 需泛型指定类型 (e.g., `List<String>`) | 可直接声明 (e.g., `ArrayList<String>`) | | **实例化** | 不能直接实例化,需实现类 | 可以直接实例化 | | **特有方法** | 只有接口方法 (如 `add()`, `get()`) | 额外方法 (如 `trimToSize()`) | | **性能** | 取决于实现类 | 随机访问快 ($O(1)$), 插入删除慢 ($O(n)$) | | **类型安全** | 高(强制泛型) | 高(但声明时可省略泛型) | | **使用推荐** | 多态编码时优先使用 | 需要特定数组行为时使用 | 在实际开发中,建议优先使用 List 接口声明变量(如 `List<String> list = new ArrayList<>();`),以保持代码灵活;只在需要 ArrayList 特有方法时才直接使用 ArrayList 类[^1][^2][^5]。 #### 相关问题 基于您的查询,我生成了以下相关问题以深化理解: 1. ArrayList 和 LinkedList 在性能上有哪些具体差异? 2. 如何在 Java 中选择合适的 List 实现类(如 ArrayList vs. LinkedList)? 3. List 接口的其他常见实现有哪些(如 Vector 或 CopyOnWriteArrayList)?
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值