List,linkeedlist集合介绍，特点,二者区别，增长因子，去重复

本文链接：https://blog.csdn.net/lz17267861157/article/details/131200092

1.list集合介绍

1.2特点

2.linkedlist 和arrylist区别

3.增长因子

4.去重复

一.list集合介绍

1.集合介绍：是一种容器，用来存储数据；就好像你的书包，用来装书！

1.2.特点：a.对数据进行增删修查 b.有序集合（0开始）c.允许重复元素

a.1.对数据进行增删修查

    List  list =new ArrayList<>();
    //增加
        list.add("设计");
        list.add("收复");
        list.add("回复");
    //删除
        list.remove("回复");
    //修改
        list.set(1, "垃圾");
    //查看
        System.out.println(list);

c.1允许重复元素

3.list集合的遍历方式

a.fore b.迭代器 c.fori(通过下标)

a.1fore(加强for循环)

List  list =new ArrayList<>();
    //增加
        list.add("设计");
        list.add("收复");
        list.add("回复");

    for (Object object : list) {
        System.out.println(object);
    }

遍历效果图

b.2迭代器

Iterator iterator = list.iterator();
    while(iterator.hasNext()) {
        System.out.println(iterator.next());
    }

遍历效果图

c.3fori(通过下标)

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

遍历效果图

二.2.linkedlist 和arrylist区别

1.ArrayList（数组）存储数据

存储过程

特点：查询，修改快（根据下标），增加删除慢；

（查询，修改）为什么快：查询就是获取原来数组那个位置下标直接查看，修改就是获得将修改元素的下标进行修改（直接在数组原上进行操作）；

（增加，删除）为什么慢：删除就是获得将删除的元素下标在进行删除，增加就是在数组获得数组最后一个元素下标在进行添加，也有可能是在集合中在中间的元素进行增加，增加后所有元素往后移一位会影响效益！

2.LinkedList (链表) 存储数据

存储过程

特点：特点：查询，修改慢，增加删除快；

（增加删除）为什么快：直接打开链表，在链表进行增加操作，删除就是在链表中的元素直接删除

（查询，修改慢）为什么慢：进行查看是假如从1开始获取3，从1左右两边同时进行查询，没有就进行下一步由于有多个过程所有慢，修改同样如此！

3.推栈：先进后出对列：先进后出

package com.lz.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import org.omg.CORBA.PUBLIC_MEMBER;

public class demo2 {
    public static void main(String[] args) {

        /**
         * LinkedList实现 推栈
         */
        // 构造linkedlist 集合
        LinkedList lz = new LinkedList<>();
        // 添加元素
        lz.add("q");
        lz.add("f");
        lz.add("e");
        // 实例化 dz class
        DZ dz = new DZ(lz);
        // 实现一个方法 先进后出
        System.out.println(dz.pop());
        System.out.println(dz.pop());
        System.out.println(dz.pop());

    }

}

// 建造一个 class 定义：LinkedList lz
class DZ {
    private LinkedList lz;

    // 返回函数 有参构造器
    public DZ(LinkedList lz) {
        super();
        this.lz = lz;
    }

    // 弹栈
    public Object pop() {
        return lz.removeLast();
    }

}

效果图

三.增长因子（0.5）

为什么会出现增长因子？因为arrylist的默认存储长度为10而你存储的数据过于多，为了提高效益！扩容就已经很必要了！

我相信可能大家会有这样一个疑问：不是说数组长度不可变但是arraylist底层是数组它长度可变就不是矛盾吗？

所有说小编我给你们代码效果图

package com.lz.list;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class demo3 {
    public static void main(String[] args) throws Exception {
    /**
     * 增长因子 (0.5) 自动扩容
     */
        // 数组长度不可变    arraylist底层是数组 长度可变
//    定义数组长度为50     (50)到50时才扩容 每次是原来的1.5倍（向下取整）
        ArrayList  list=new ArrayList<>(50);
        for (int i = 0; i < 100; i++) {
            list.add(i);
            System.out.print(i+"\r");
            getLength(list);    
        }
        
    }
//    arraylist数组长度可变
    private static void getLength(ArrayList list) throws Exception, Exception {
        Field f = list.getClass().getDeclaredField("elementData");
        f.setAccessible(true);
        Object[] object = (Object[]) f.get(list);
        System.out.println("当前数组长度： "+object.length);
    }
}

效果图

四.去重复

1.字符串去重

package com.lz.list;

import java.util.ArrayList;
import java.util.List;

public class demo4 {
    public static void main(String[] args) throws Exception {
        /**
         * 去除重复元素
         */
        // 1.字符串
        List list = new ArrayList<>();
        list.add("q");
        list.add("f");
        list.add("h");
        System.out.println("当前原素：" + list);
        if (!list.contains("h")) {
            list.add("h");
        }
        System.out.println("当前原素：" + list);

    }

效果图：

2.对象去重

package com.lz.list;

import java.util.ArrayList;
import java.util.List;

public class demo4 {
    public static void main(String[] args) {
    //对象
        List list = new ArrayList<>();
        list.add(new  stu("多久哦"));
        list.add(new  stu("山东积分"));
        list.add(new  stu("速度放缓"));
        System.out.println("当前原素：" + list);
        if (!list.contains(new  stu("多久哦"))) {
            list.add(new  stu("多久哦"));
        }
        System.out.println("现在原素：" + list); 
        
    }
}
class  stu{ 
    private   String  name;
public stu() {
    // TODO Auto-generated constructor stub
}
    
    /* (non-Javadoc)
 * @see java.lang.Object#toString()
 */
@Override
public String toString() {
    return "stu [name=" + name + "]";
}

    public String getName() {
        return name;
    }

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

    public stu(String name) {
        super();
        this.name = name;
    }
    /* (non-Javadoc)
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    /* (non-Javadoc)
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(Object obj) {
        //为什么 会这样原因是    equals方法返回值相关
        System.out.println("送积分");
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        stu other = (stu) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    
    
}

效果图：