java集合之List案例详解

List集合的特点：有序可重复

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

/* 设计⼀个⽅法，删除⼀个集合中，所有的指定的元素。
例如，将集合中所有的3都删除。*/
public class HWork1 {
    public static void main(String[] args) {
        
        }
        //设计方法
    public static boolean remove(List<?> l1, Object ele){
         boolean l2 = l1.removeIf(e -> e.equals(ele));
         return l2;
    }
    }



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

/*设计⼀个⽅法，将⼀个存储有体重信息的集合，所有的数据乘2*/
public class HWork2 {
    public static void main(String[] args) {

    }
    private static void replace(List<Integer> list){
        //replaceAll:将集合中的元素带⼊到接⼝⽅法中， ⽤返回值替换原来的元素。
        list.replaceAll(ele -> ele * 2 );
    }
}



/*设计⼀个⽅法，在⼀个存储了若⼲个视频的集合中
，删除所有的以 .mp4结尾的元素。*/
public class HWork3 {
    public static void main(String[] args) {
    }

    private static boolean remove(List<String> list){
        boolean l3 = list.removeIf(name -> name.endsWith(".mp4"));
        return l3;
    }
}


package homework;
/*随机⽣成20个整数，范围为10-30，
存⼊到集合中，将所有元素加和后输出。*/

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

public class HWork4 {
    public static void main(String[] args) {
    }
    public static void test1(List list){
        //临时变量求和sum
        int sum = 0;
        Random random = new Random();
        //for循环输出的应该是<20 因为范围有要求
        for (int i = 0; i < 20; i++) {
            //临时遍历numbe存随机数
            //让number从10开始，然后随机生成的数为20内
            //范围是：10 - 30
            int number =10 + random.nextInt(20);
            //然后再一个一个往集合里面去加值
            list.add(number);
            //将所有元素的和输出：就是集合的每个值相加
            //所以每当进行赋值一次就相加一次
            sum += number;
        }
        //在for循环外面打印sum 因为上面没给返回值
        System.out.println("指定范围内元素的和为："+sum);
    }
}


import java.util.Arrays;

/*设计⼀个MyArrayList类，实现不定⻓度实现的基本功能:*/
/*1. MyArrayList中添加的元素，可以通过泛型进⾏限定
2. 向MyArrayList中添加元素
3. 从MyArrayList中删除元素（按照下标删除、按照元素删除、清空所有）
4. 通过下标，获取元素
5. 通过下标，修改元素
6. 将MyArrayList中的元素进⾏升序排序*/
public class HWork5 {
}

//我的数组工具类 泛型
class MyArrayList<E> {
    //私有成员是Object[]类的集合
    private Object[] elements;

    //构造无参构造方法 注意：泛型不能作为构造方法使用
    public MyArrayList() {
        this.elements = new Object[0];
    }

    //求集合长度
    public int size() {
        return this.elements.length;
    }

    //向集合之中添加元素
    public void add(E element) {
        //利用集合的copyOf方法，对集合的长度进行动态扩充
        //进行强制类型转换
        //这是一个名为copy的集合 它的长度是原集合的长度+1
        E[] copy = (E[]) Arrays.copyOf(this.elements, size() + 1);
        //这是把加进来的这个元素放进这个原集合添加的长度
        copy[size()] = element;
        //把新集合赋予原来的集合 调用方法的时候就可添加元素
        this.elements = copy;
    }

    //清空集合所有元素 注意不是null 就类似房子还在 东西清空了而已
    public void clear() {
        this.elements = new Object[0];
    }

    //按照下标进行删除元素
    public E remove(int index) {
        //E:是泛型的意思 创建一个泛型的对象，需要的是向下转型 强制类型转换
        E e = (E) this.elements[index];
        //static void
        // arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
        //从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束
        System.arraycopy(this.elements, index + 1, this.elements, index, size() - index - 1);
        this.elements = Arrays.copyOf(this.elements, size() - 1);
        return e;
    }

    //按照元素进行删除
    public boolean remove(E e) {
        //创建一个方法进行判断
        //如果这个集合元素指定的下标存在
        //删除这个元素
        int index = indexof(e);
        if (index != -1) {
            remove(index);
            return true;
        } else {
            return false;
        }
    }

    //输入一个泛型的元素 进行判断 存在就返回它
    //执行上面的方法
    public int indexof(E e) {
        for (int i = 0; i < this.elements.length; i++) {
            if (this.elements[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }

    //通过下标获取元素
    public E get(int index) {
        return (E) this.elements[index];
    }

    //修改元素
    public void set(E e) {
        int index = indexof(e);
        if (index != 1) {
            this.elements[index] = e;
        }
    }

    //通过下标修改元素
    public void set(int index, E e) {
        this.elements[index] = e;
    }
}
    //编写排序方法，让用户自己决定比较规则
/*    public void sort(Comparator<E> comparator){
        for (int i = 0; i < this.elements.length-1; i++) {
            for (int j = 0; j < this.elements.length-1-i; j++) {
                if (comparator.compare((E)this.elements[j],(E)this.elements[j+1])>0){
                    E e = (E)this.elements[j];
                    this.elements[j] = (E)this.elements[j+1];
                    this.elements[j+1]  = (E)this.elements[j];
                }
            }
        }
    }
    public String toString(){
        return Arrays.toString(elements);
    }
}*/