java list替换指定位置元素_Java学习笔记day10

最新推荐文章于 2024-05-20 17:06:33 发布

AntiBolshevism

最新推荐文章于 2024-05-20 17:06:33 发布

阅读量5.2k

点赞数 1

文章标签： java list替换指定位置元素

本文链接：https://blog.csdn.net/weixin_42361237/article/details/112081237

版权

List集合
java.lang.list接口 extends Collection接口
list接口的特点：
1.有许多集和，存储元素和取出元素的顺序是一致的（存储123，取出123）
2.有索引，包含以下带索引的方法
3.允许存储重复的元素
list接口中带索引的方法(四种)
public void add(int index, E element):将指定元素，添加到该集合的指定位置上
public E get(int index):返回集合中指定位置的元素
public E remove(int index):移除列表中指定位置的元素，返回的是被移除的元素
public E set(int index, E element):用指定元素替换集合中指定位置掉元素，返回值是更新前的元素
注意：
操作索引的时候，一定防止索引越界异常
IndexOutOfBoundsException：索引越界异常
ArrayIndexOutOfBoundsException：数组索引越界异常
StringIndexOutOfBoundsException：字符串索引越界异常

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

public class Demo01List {
    public static void main(String[] args) {
        //创建一个list集合对象，多态
        List<String> list = new ArrayList<>();
        //使用add方法往集合中添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("a");
        //打印集合
        System.out.println(list);//[a, b, c, d, a] 不是地址重写了toString

        //public void add(int index, E element):将指定元素，添加到该集合的指定位置上
        //在c和d之间添加一个itheima
        list.add(3,"itheima");
        System.out.println(list);

        //public E remove(int index):移除列表中指定位置的元素，返回的是被移除的元素
        //移除元素
        String removeE = list.remove(2);
        System.out.println("被移除的元素：" + removeE);
        System.out.println(list);

        //public E set(int index, E element):用指定元素替换集合中指定位置掉元素，返回值是更新前的元素
        //最后一个a替换为4
        String setE = list.set(4, "A");
        System.out.println("被替换的元素：" + setE);
        System.out.println(list);

        //list集合遍历的3种方法
        //使用普通的for循环
        for (int i = 0; i < list.size(); i++) {
            //public E get(int index):返回集合中指定位置的元素
            String s = list.get(i);
            System.out.println(s);
        }
        System.out.println("-----------------------");

        //使用迭代器
        Iterator<String> it = list.iterator();
        while(it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-----------------------");

        //增强for循环
        for (String s : list) {
            System.out.println(s);
        }

//        String r = list.get(5);
//        System.out.println(r);//IndexOutOfBoundsException
    }
}

LinkedList集合
java.util.LinkedList 集合 implements list接口
LinkedList集合的特点：
1.底层是一个链表结构，查询慢，增删快
2.包含大量操作首位元素的方法
3.使用LinkedList集合特有的方法不能使用多态
public void addFirst(E e):将指定元素插入列表的开头
public void addLast(E e):将指定元素添加到此列表的结尾
public void push(E e):将元素推入此列表所表示的堆栈
public E getFirst():返回列表第一个元素
public E getLast():返回列表最后一个元素
public E removeFirst():移除并返回列表的第一个元素
public E removeLast()：移除并返回列表的最后一个元素
public E pop():从此列表所表示的对战弹出一个元素
public boolean isEmpty():如果列表不包含元素，则返回true

import java.util.LinkedList;

public class Demo02LinkedList {
    public static void main(String[] args) {
//        show01();
//        show02();
        show03();
    }
//    public E removeFirst():移除并返回列表的第一个元素
//    public E removeLast()：移除并返回列表的最后一个元素
//    public E pop():从此列表所表示的对战弹出一个元素
    private static void show03() {
        //创建LinkedList集合对象
        LinkedList<String> linked = new LinkedList<>();
        //使用add方法添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");
        System.out.println(linked);

        String first = linked.removeFirst();
        System.out.println("被移除的第一个元素：" + first);
        String last = linked.removeLast();
        System.out.println("被移除的最后一个元素：" + last);
        System.out.println(linked);

    }

    private static void show02() {
        //创建LinkedList集合对象
        LinkedList<String> linked = new LinkedList<>();
        //使用add方法添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");
        System.out.println(linked);

        //linked.clear();//情况集合中的元素，再获取元素就会抛出NoSuchElementException

        //public boolean isEmpty():如果列表不包含元素，则返回true

        if (!linked.isEmpty()){
            String first = linked.getFirst();
            System.out.println(first);
            String last = linked.getLast();
            System.out.println(last);
        }
    }

    private static void show01() {
        //创建LinkedList集合对象
        LinkedList<String> linked = new LinkedList<>();
        //使用add方法添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");
        System.out.println(linked);

        ///public void addFirst(E e):将指定元素插入列表的开头
//        linked.addFirst("www");
        linked.push("www");
        System.out.println(linked);

        //public void addLast(E e):将指定元素添加到此列表的结尾,等效于add()
        linked.addLast("com");
        System.out.println(linked);
    }
}

Vector集合，ArrayList集合，LinkedList集合

1.Vector简介及特点

1、Vector是内部是以动态数组的形式来存储数据的。
2、Vector具有数组所具有的特性、通过索引支持随机访问、所以通过随机访问Vector中的元素效率非常高、但是执行插入、删除时效率比较地下、具体原因后面有分析。
3、Vector实现了AbstractList抽象类、List接口、所以其更具有了AbstractList和List的功能、前面我们知道AbstractList内部已经实现了获取Iterator和ListIterator的方法、所以Vector只需关心对数组操作的方法的实现、
4、Vector实现了RandomAccess接口、此接口只有声明、没有方法体、表示Vector支持随机访问。
5、Vector实现了Cloneable接口、此接口只有声明、没有方法体、表示Vector支持克隆。
6、Vector实现了Serializable接口、此接口只有声明、没有方法体、表示Vector支持序列化、即可以将Vector以流的形式通过ObjectOutputStream来写入到流中。
7、Vector是线程安全的。

2.ArrayList的特点

1、容量不固定，想放多少放多少（当然有最大阈值，但一般达不到）

2、有序的（元素输出顺序与输入顺序一致）

3、非线程安全

4、插入元素的时候可能扩容，删除元素时不会缩小容量，不使用索引的元素查找需要遍历数组，并使用equals比较。

详解方法：

增加：
1、因为是数组实现，ArrayList的代价会大一些，而且会考虑是否需要扩容，首先在原有元素个数上加一为minCapacity,用这个值和Ooject数组大小进行比较（容量），如果这个值大，那么就需要扩容了，将数组的size*1.5+1，如果此时还是minCapacity的话，那么新容量就用minCapacity来表示，然后就是生成新的容量的数组，原来的元素赋值进去即可，如果想更改扩容策略，继承ArrayList，重写ensureCapacity方法即可。
2、add(E)把新添加的元素放到数组的末尾，只需要使用常数的时间。
3、add(int,E)在数组指定位置添加元素，首先确定数组这个位置是否存在和容量是否允许，然后将指定位置后面的所有元素全部向后面移动一个位置，最后才将元素插入进指定位置，使用O(n)的时间代价。
删除：
删除分两种删除，删除对象和按位置删除。

1. 删除对象（空，和非空，但都需要遍历）

1、如果删除的对象为空（null），首先遍历数组元素是否有为空，若有，将使用fastRemove方法删除，具体做法是，将此位置后面的元素全部向前移动一位，最后的那个留空，并可以gc回收了。
2、如果不为空，使用equals方法进行比较，找到了相应的元素后，同样进行faseRemove方法进行删除。
2.按位置删除

1.remove(int)删除指定位置的元素，这是数组的优势，大大提升了性能，仅仅只需要判断index是否越界，剩下的就是直接删除了，不需要遍历。但是该元素后的元素同样需要全部向前移动一位。
获取单个对象：
get(int)，首先判断是否越界，然后就是直接返回元素了，这也是数组的优势。
遍历：
常用的迭代器设计模式，iterator方法返回一个父类实现的迭代器。
1、迭代器的hasNext方法的作用是判断当前位置是否是数组最后一个位置，相等为false，否则为true。
2、迭代器next方法用于返回当前的元素，并把指针指向下一个元素，值得注意的是，每次使用next方法的时候，都会判断创建迭代器获取的这个容器的计数器modCount是否与此时的不相等，不相等说明集合的大小被修改过，如果是会抛出ConcurrentModificationException异常，如果相等调用get方法返回元素即可。
判断元素是否存在：
1、首先判断条件元素是否为空，是则遍历集合，有就返回true，否则false。
2、不为空，则使用equals方法，需要遍历集合。

3.LinkedList的特点

是一个双链表，在add和remove时比ArrayList性能好，但get和set时就特别慢了。
恶补下：
双向链表，链表的一种。每个数据结点中都有两个指针，分别指向直接前驱和直接后继。因此，我们可以方便的访问他的前驱结点和后继结点。

1、链表简介：
链表是常用的一种数据结构、关于链表这里只给出简单介绍、只是基础的概念。
1、概念：
如果一个节点包含指向另一个节点的数据值，那么多个节点可以连接成一串，只通过一个变量访问整个节点序列，这样的节点序列称为链表（linked list）
2、单向链表：
如果每个节点仅包含其指向后继节点的引用，这样的链表称为单向链表。
3、双向链表：
每个链表节点，包含两个引用，一个指向前驱节点，一个指向后驱节点，也就是——双向链表。
2、LinkedList的特点：
1、 LinkedList以链表的形式存储数据、对增删元素有很高的效率、查询效率较低、尤其是随机访问、效率不忍直视、
2、 LinkedList继承AbstractSequentialdList（其继承与AbstractList、所以要求其子类要实现通过索引操作元素）、使得LinkedList支持使用索引的“增删改查”操作、
3、LinkedList直接实现了List接口、使其可以内部存储元素有序并且为每个元素提供索引值、
4、LinkedList直接实现了Deque接口、Deque接口继承了Queue、使其可以作为双向链表这种数据结构来使用、操作元素、
5、LinkedList直接实现了Cloneable接口、使其可以复制其中的全部元素
6、在使用ObjectOutputStream/ObjectInputStream流时、会先讲LinkedList的capacity读取/写入到流中、然后将元素一一读取/写入。

HashSet集合

内部无序，封装了HashMap。就是用HashMap的key位来存储值.

java.util.Set接口 extends Collection接口
Set接口的特点：
1.不允许存储重复的元素
2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
java.util.HashSet集合 implements Set 接口
HashSet特点：
1.不允许存储重复元素、
2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
3.是一个无序集合，存储元素和取出元素的顺序有可能不一致
4.底层是一个哈希表结构(查询速度非常的快 )

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Demo01Set {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        //使用add方法往集合中添加元素
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(1);
        //使用迭代器遍历set集合
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()) {
            Integer n = it.next();
            System.out.println(n);
        }
        System.out.println("---------------------");
        //使用增强for遍历set集合
        for (Integer i : set) {
            System.out.println(i);
        }
    }
}

LinkedHashSet集合

java.util.linkedHashSet集合 extends HashSet集合
LinkedHashSet集合特点：
底层是一个哈希表(数组+链表/红黑树)+链表：多了一个条链表(记录元素的存储顺序)，保证元素有序

public class Demo04LinkedHashSet {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("www");
        set.add("abc");
        set.add("abc");
        set.add("itcast");
        System.out.println(set);//[abc, www, itcast]无序不允许重复

        HashSet<String> linked = new LinkedHashSet<>();
        linked.add("www");
        linked.add("abc");
        linked.add("abc");
        linked.add("itcast");
        System.out.println(linked);//[www, abc, itcast]有序，不允许重复
    }
}

重写hashCode和equals方法

import java.util.Objects;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

哈希值（hashCode）
哈希值：是一个十进制的整数，由系统随即给出（就是对象的地址值，是一个逻辑地址，不是物理地址）
Object类中有个方法，可以获得对象的哈希值
int hashCode() 返回该对象的哈希值
hashCode方法源码：
public native int hashCode();
native:代表该方法调用的是本地操作系统的方法

public class Demo01HashCode {
    public static void main(String[] args) {
        //person类继承了Object类，所以可以使用Object类的hashCode方法
        Person p1 = new Person();
        int h1 =p1.hashCode();
        System.out.println(h1);//189568618

        Person p2 = new Person();
        int h2 =p2.hashCode();
        System.out.println(h2);//793589513

        /*
            toString方法的源码：
                return getClass().getName() + "@" + Integer.toHexString(HasCode());
         */
        System.out.println(p1);//b4c966a
        System.out.println(p2);//2f4d3709
        System.out.println(p1 == p2);

        /*
            String 类的哈希值
                String类重写Object类的ashCode方法
         */

        String s1 = new String("ABC");
        String s2 = new String("ABC");
        System.out.println(s1.hashCode());//64578
        System.out.println(s2.hashCode());//64578
    }
}

重写hashCode

public class Person extends Object {
    //重写hashCode方法


    @Override
    public int hashCode() {
        return 1;
    }
}

Collections集合工具类

java.utils.Collections是集合工具类，用来对集合进行操作。public static <T> boolean addAll(Collection<T> c,T... elements):往集合中添加一些元素public static void shuffle(List<?> list) 打乱集合顺序

import java.util.ArrayList;
import java.util.Collections;

public class Demo01Collections {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        //往集合中添加元素
//        list.add("a");
//        list.add("b");
//        list.add("c");
//        list.add("d");
//        list.add("e");

        //public static <T> boolean addAll(Collection<T> c,T... elements):往集合中添加一些元素
        Collections.addAll(list,"a","b","c","d","e");
        System.out.println(list);//[a,b,c,d,e]

        //public static void shuffle(List<?> list) 打乱集合顺序
        Collections.shuffle(list);
        System.out.println(list);//[d, e, a, b, c]
    }
}

java.utils.Collections是集合工具类，用来对集合进行操作。public static <T> void sort(List<T> list):将集合中元素按照默认规则排序
注意：
sort(list<> list)使用前提
被排序的集合里边存储的元素，必须实现Comparable，重写接口中的方法compareTo定义排序的规则Comparable接口排序规则：
自己(this) - 参数:升序

import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.Callable;

public class Demo02Sort {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(3);
        list01.add(2);
        System.out.println(list01);//[1, 3, 2]
        //public static <T> void sort(List<T> list):将集合中元素按照默认规则排序
        Collections.sort(list01);
        System.out.println(list01);//[1, 2, 3]

        ArrayList<String> list02 = new ArrayList<>();
        list02.add("a");
        list02.add("c");
        list02.add("b");
        System.out.println(list02);//[a, c, b]
        Collections.sort(list02);
        System.out.println(list02);//[a, b, c]

        ArrayList<Person> list03 = new ArrayList<>();
        list03.add(new Person("张三",18));
        list03.add(new Person("李四",20));
        list03.add(new Person("王五",15));
        System.out.println(list03);//[Person{name='张三', age=18}, Person{name='李四', age=20}, Person{name='王五', age=15}]

        Collections.sort(list03);
        System.out.println(list03);
    }
}

java.utils.Collections是集合工具类，用来对集合进行操作。
public static <T> void sort(List<T> list,Comparable<? super T>):将集合中元素按照指定规则排序
Comparator和Comparable的区别
Comparable：自己(this)和别人(参数)比较，自己需要实现Comparable接口，重写比较的规则compareTo方法
Comparator：找一个第三方的裁判，比较两个
Comparator排序规则：
o1 - o2 :升序
o2 - o1 :降序

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Demo03Sort {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(3);
        list01.add(2);
        System.out.println(list01);//[1, 3, 2]

        Collections.sort(list01, new Comparator<Integer>() {
            //重写比较的规则
            @Override
            public int compare(Integer o1, Integer o2) {
//                return 0;
            return o1 - o2;//升序
            }
        });

        System.out.println(list01);

        ArrayList<Student> list02 = new ArrayList<>();
        list02.add(new Student("a迪丽热巴",18));
        list02.add(new Student("古力娜扎",20));
        list02.add(new Student("杨幂",17));
        list02.add(new Student("b杨幂",18));
        System.out.println(list02);

//        Collections.sort(list02, new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
                return 0;
//                //按照年龄升序
//                return o1.getAge() - o2.getAge();
//            }
//        });

        Collections.sort(list02, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
//                return 0;
                //按照年龄升序
                int result =  o1.getAge() - o2.getAge();
                //如果两人年龄相同，在使用姓名第一个字比较
                if (result == 0) {
                    result = o1.getName().charAt(0) - o2.getName().charAt(0);
                }
                return result;
            }

        });
        System.out.println(list02);
    }
}

重写排序的规则

public class Person implements Comparable<Person>{
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    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 int compareTo(Person o) {
        //return 0;//认为元素都是相同的
        //自定义比较规则比较两个人的年龄（this.参数Person）
        return this.getAge() - o.getAge();//年龄升序排序
//        return o.getAge() - this.getAge();//降序排列
    }
}

AntiBolshevism

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java list替换指定位置元素_Java学习笔记day10

List集合 java.lang.list接口 extends Collection接口 list接口的特点： 1.有许多集和，存储元素和取出元素的顺序是一致的（存储123，取出123） 2.有索引，包含以下带索引的方法 3.允许存储重复的元素 list接口中带索引的方法(四种) public void add(int in...
复制链接

扫一扫